Goto prompt:
>setup
choose “Firewall configuration”
choose “Customize”
choose “Other ports” 8080:tcp
choose “Ok”
>service tomcat6 restart
cd /etc/yum.repos.d
wget ‘http://www.jpackage.org/jpackage50.repo’
yum update
yum install tomcat6 tomcat6-webapps tomcat6-admin-webapps
service tomcat6 start
If you get a dependency then do this and do above again:
The shell for a user is in the /etc/passwd file for that user as the last field.
Or echo the ‘SHELL’ variable on the command prompt:
echo $SHELL
From MSDN : http://msdn.microsoft.com/en-us/library/dd920295%28VS.95%29.aspx
With Silverlight, you can specify whether the browser or the client provides HTTP handling for your Silverlight-based applications. By default, HTTP handling is performed by the browser and you must opt-in to client HTTP handling.
The following is a list of scenarios that you would typically specify client HTTP handling for.
In addition to specifying whether to use browser or client HTTP handling, you can specify the scope for the handling. For example, you can specify HTTP handling for all messages, for a scheme (HTTP or HTTPS), for a particular domain, or for a single request object. Once you have specified the HTTP handling for a scheme or domain, you cannot change the HTTP handling for that domain or scheme. The following procedures describe how to specify browser or client HTTP handling, set the scope of the handling, and how to determine whether the browser or client is performing the handling for a request object.
From MSDN:
When publishing or refreshing tasks in Microsoft Project, there is a mapping file that specifies how the fields in each task are mapped to fields in Team Foundation. Also the mapping file controls the publishing behavior, and designates special fields that display additional information, such as the context field.
You can customize the behavior when tasks are published or refreshed. You can change which fields in Team Foundation are mapped to Microsoft Project fields. You can control if fields are only published, or both published and refreshed. And you can designate special fields that are the links and attachments, context field, and synchronization field.
TFS WorkItems CoreField enum can be used to access various fileds in a work item. For example
workItem.Fields[CoreField.AssignedTo].Value = "Emma Smith";
The values for this enum are as below:
| Id | ||
| Rev | ||
| Title | ||
| Description | ||
| WorkItemType | ||
| TeamProject | ||
| State | ||
| Reason | ||
| CreatedBy | Can be a user other than the one who is authenticated. See AuthorizedAs. | |
| AssignedTo | ||
| ChangedBy | ||
| ChangedDate | ||
| CreatedDate | ||
| RevisedDate | ||
| AuthorizedAs | The “person name” field, used to store the name of the user who is authenticated to make the change. | |
| History | ||
| AreaPath | ||
| AreaId | ||
| IterationPath | ||
| IterationId | ||
| NodeName | ||
| RelatedLinkCount | ||
| HyperLinkCount | ||
| AttachedFileCount | ||
| ExternalLinkCount |
As an instance of the XPath 2.0 data model, the XPathNavigator class can contain strongly-typed data that maps to common language runtime (CLR) types. According to the XPath 2.0 data model, only elements and attributes can contain strongly-typed data. The XPathNavigator class provides mechanisms for accessing data within an XPathDocument or XmlDocument object as strongly-typed data as well as mechanisms for converting from one data type to another.
http://msdn.microsoft.com/en-us/library/1bkbyzbb(VS.80).aspx
DECLARE @name varchar(500)
DECLARE @sql varchar(8000)
SET @sql = ”
DECLARE Database_Cursor CURSOR READ_ONLY FOR
SELECT Name
FROM sysdatabases
WHERE DBID > 4
OPEN Database_Cursor
FETCH NEXT FROM Database_Cursor INTO @name
WHILE @@FETCH_STATUS = 0
BEGIN
SET @sql = @sql + ‘ALTER DATABASE [‘ + @name + ‘] SET AUTO_SHRINK OFF’ + CHAR(10)
FETCH NEXT FROM Database_Cursor INTO @name
END
CLOSE Database_Cursor
DEALLOCATE Database_Cursor
print @sql
EXEC(@sql)
FETCH NEXT FROM Database_Cursor INTO @name
EXEC(@sql)
from: http://weblogs.asp.net/dmckinstry/archive/2006/12/04/moving-tfs-databases.aspx
TFS was down! The problem appeared to be that the TFS databases were installed on the default C drive which was too small and completely out of space. They were pretty sure they knew the answer but wanted me to verify it. For everyone’s benefits, I’ve documented the steps we used to move the TFS-related databases from the C drive to another location.
Note that they were already at a stop-work situation so things couldn’t get too much worse. If you need to do something similar you should approach the process gingerly. Make sure your backups are good and realize that while you’re doing this the TFS and its related services will be unavailable.
Problem:
Error TF84037: There was a problem initializing the Microsoft Excel Team Foundation Addin. Re-installing the Team Foundation Client may be required.
Solution:
Office 2003 .Net programmability support is not installed. You need to modify your installed version of Office and install this option. I thought we had a better error message for this…
1. In Add/Remove programs, locate your Office application and select it.
2. Click on the ‘Change’ button
3. Select ‘Add or Remove features’ and click ‘next’
4. Select ‘Choose advanced customization of applications’ and click ‘next’
5. In the tree view, expand ‘Microsoft Office Excel’ and make sure the .NET Programmability Support option is set to ‘run from my computer’.
6. Click ‘update’.
from MSDN
BeautyTips is a jQuery tooltips plugin which uses the canvas drawing element in the HTML5 spec in order to dynamically draw tooltips (sometimes called “talk bubbles” or “help balloons”) associated with a html element on the page. These tips are highly configurable and can be triggered in many different ways.
see: http://visifire.com/
The WilsonXmlDbClient is an ADO.NET provider that enables Xml to be worked with just like any other database in .NET. It supports the most common Select, Insert, Update, and Delete SQL syntax, as well as tranactions and parameters.
Wilson.XmlDbClient is the original open source release by Paul Wilson. It includes:
XmlDbCommand
XmlDbDataReader
XmlDbDataAdapter
XmlDbConnection
XmlDbParameter
XmlDbTransaction
XmlDbException
taken directly from: http://bappedyanto.com/post/Delete-Work-Item-in-TFS.aspx
In TFS 2008, there’s a capability to delete unused work item. I know some people think that physically delete the work item is not needed because there are several work around to achieve it, nevertheless for the reason of tidiness everything, delete work item physically sometimes is required.
Out of the box, this feature is not available. You need to install TFS 2008 Power Tools and use the TFPT.EXE command line tools (although I believe GUI will be more than useful).
Be careful now, there’s no way to recover or undelete the work item by executing this tool.
As the description suggest, using this tool is not deleting records in datawarehouse (TFS uses SQL Server both OLTP and OLAP), only in operational database. The implication is the deleted work item will still appear in Team Reporting.
To fix this, manual deletion is required in TFS Datawarehouse database, some people will say that this practice is dangerous because potentially will break the data integrity but I think if we do it properly, the risk can be eliminated.
in SQL Management Studio, connect to TFS Database Server, and then unfold TFSWarehouse database.
Notice five tables with name related to work item. [Current Work Item], [Work Item], [Work Item Changeset], [Work Item History], and [Work Item with Result].
Query [Work Item] table to get the work item id in Datawarehouse with this SQL statement
SELECT __ID, System_Title FROM [Work Item] WHERE System_Id = workitemid
workitemid in here is the work items id that is used in TFPT command. Don’t get confused because in other 4 tables that previously noted the work item id that will be used is coming from [Work Item].__ID.
For the other 4 tables here’s the SQL statement that need to be executed
Delete [table name] where [work item] = workitem_from_[Work Item].__ID
Then rebuilt you cube by executing the OLAP Database and Warehouse Run from web services.
Disclaimer : please be very careful when conducting this procedure. I am not responsible if your TFS data is messed up
This white paper consolidates general information, best practices, and tips for designing Microsoft SQL Server Reporting Services (SSRS) reports. It is intended to provide a starting point for design questions and an overview of some of the capabilities of Reporting Services. (12 printed pages)
http://msdn.microsoft.com/en-us/library/aa964129(SQL.90).aspx
A Visual Studio template that gives a basic framework for editing MSBuild project files from within the Visual Studio IDE, also supporting Source Control without leaving the Solution Explorer window.
UPDATE dbo.geo_postcode
SET dbo.geo_postcode.geo_region_name = dbo.geo_region.geo_region_name
FROM dbo.geo_postcode
INNER JOIN dbo.geo_region
ON (dbo.geo_postcode.geo_region_code = dbo.geo_region.geo_region_code and dbo.geo_postcode.geo_country_code = dbo.geo_region.geo_country_code);
the below is taken from:
http://www.developerfusion.com/article/4272/net-threading-part-ii/3/
The Thread class and System. Threading namespace also contain some methods and classes for realizing thread local storage. Thread local storage is a manner of storing data in a container that is unique to the thread. Many threads could then use the same named container to store their data without concern of collision. Each thread’s local storage is distinct from another thread’s local storage and is only available in the one thread. Listing 3 shows a small sample using the thread-local-storage methods and classes.
using System;
using System.Threading;
namespace ConsoleApplication11
{
class Class1
{
public void ThreadStart()
{
string str1 = "My Cookie "+
Thread.CurrentThread.GetHashCode();
Console.WriteLine("worker thread: {0}", str1);
LocalDataStoreSlot lds =
Thread.GetNamedDataSlot("COOKIE");
Thread.SetData(lds, str1);
Thread.Sleep(1);
LocalDataStoreSlot lds2 =
Thread.GetNamedDataSlot("COOKIE");
string str2 = "";
str2 = (string) Thread.GetData(lds2);
Console.WriteLine("worker thread: {0}", str2);
}
static void Main(string[] args)
{
string str1 = "My Cookie "+
Thread.CurrentThread.GetHashCode();
Console.WriteLine("main thread: {0}", str1);
LocalDataStoreSlot lds =
Thread.AllocateNamedDataSlot("COOKIE");
Thread.SetData(lds, str1);
Class1 obj = new Class1();
Thread thread = new Thread(
new ThreadStart(obj.ThreadStart));
thread.Start();
Thread.Sleep(1);
LocalDataStoreSlot lds2 =
Thread.GetNamedDataSlot("COOKIE");
string str2 = "";
str2 = (string) Thread.GetData(lds2);
Console.WriteLine("main thread: {0}", str2);
}
}
}
You could also create and start more than one thread and the behavior of the thread local storage becomes more obvious. I have played with Win32 thread-local-storage functions and created my own for portability to UNIX, but I have rarely found them very useful. I strongly believe in stateless computing and thread-local-storage contradicts this belief.
Interesting from:
http://msdn.microsoft.com/en-us/magazine/dd419664.aspx
“Consider a pipeline implementation that obtains parallelism benefits by having multiple stages of the pipeline active at any one time.
If your using MSBuild (as we do with our TFS environment) then the following is most useful:
Includes:
Download from: http://www.microsoft.com/downloads/details.aspx?familyid=FBD14EEA-781F-45A1-8C46-9F6BA2F68BF0&displaylang=en
see http://blogs.msdn.com/bharry/archive/2008/01/15/checking-your-tfs-version-and-extending-trials.aspx
“The program is called TFSVersionDetection.exe and is attached to this blog post (use link above). I recommend that you run the tool on the TFS server itself. You can run it from another machine and point it at the TFS server but it does a less thorough job of detection (due to permissions issues, etc). If you run it on the TFS server and press the “Check” button, you will see a screen that look something like the following.”
Source telerik:
“There have been a number of questions, regarding the RadEditor for MOSS and whether it is possible to use it in the SharePoint 2007 Wiki libraries and sites. The short answer to this question is – yes it’s possible. Here is the long version: Wiki pages in MOSS 2007 are stored as normal document libraries. This means that when you edit a Wiki page, you are actually editing a list item. RadEditor for MOSS supports this scenario and you can use it to replace the default editor in all major browsers – Internet Explorer, Firefox, Safari, etc.
Here is how to activate the RadEditor for MOSS list items (the same guide is available in the RadEditor for MOSS documentation topic Using RadEditor in List Items):
1. You need to get the latest build of our editor. Go to this page for more info and download details – http://www.telerik.com/products/sharepoint/overview.aspx
2. Install the RadEditor for MOSS in your web farm. Installation instructions are available in the documentation, which comes with the download.
3. Browse to the SharePoint site which, where you want to use the RadEditor in list items and open the Site Settings page. From the Site Settings, navigate to Site Features.
4. Activate the RadEditor features. You can use the editor in all browsers, or you can leave the default rich text editor in Internet Explorer and use ours everywhere else. Here is a screenshot with the RadEditor features:
5. You might need to restart IIS to recycle the SharePoint web application. This step is required since MOSS will cache the default editor the first time it is used.
6. That’s it. You can now use RadEditor for MOSS to edit Wiki pages in your site. Remember that the RadEditor features are local to the site, so if you want to edit list items in a different site, you need to redo steps 3 and 4 for it.
After you have our editor up and running, you might want to customize its appearance/options. You can do that with the editor’s tools and configuration files. By default, they are located at \Program Files\Common Files\Microsoft Shared\web server extensions\wpresources\RadEditorSharePoint\4.1.0.0__1f131a624888eeed\RadControls\Editor\ (where 4.1.0 represents the installed editor build). The files you need to modify are called ListToolsFile.xml and ListConfigFile.xml”
Open your core.css file and find this line: “select.ms-sbscopes” . This is the css class which is responsible for the search scope dropdown in MOSS 2007.
Now just add this line within the class..:
display:none;
.. and you are done!
Note: If you don’t want to edit the core.css, you can also add the following line on any css file which will be loaded on the page (or direct on the masterpage):
select.ms-sbscopes { display:none; }
(from Gee’s Blog)
Go to Control Panel -> Add and Remove Programs. Select the product (sharepoint server) and then click: Click here for support
Now a window will pop up that displays your current sharepoint version.
Useful if your running the Virtual PC image of VS 2010 etc
Jeff Beehler: “Selecting the right branching strategy is one of the most important aspects of TFS deployment. Picking the right strategy can lead to optimized team cooperation, increased productivity and a successful adoption. On the other hand, selecting a bad branching strategy can cause frustration, damage productivity and derail TFS adoption in an organization. We have therefore put a lot of effort in creating a set of practical guidance to educate our customers and partners and support their VSTS adoption efforts.”
You can see the guide at (came out late dec 2008):
The CTP (Community Technology Preview) for Visual Studio 2010 including .Net 4.0 can be downloaded from:
”
Small Basic is a project that’s aimed at bringing “fun” back to programming. By providing a small and easy to learn programming language in a friendly and inviting development environment, Small Basic makes programming a breeze. Ideal for kids and adults alike, Small Basic helps beginners take the first step into the wonderful world of programming.
”
XML Notepad 2006 provides a simple intuitive User Interface for browsing and editing XML documents. XML Notepad shows how to use some advanced features of System.XML in the .NET Frameworks 2.0. The download includes source code. See the handy design doc that goes with it. Features include:
See : http://blogs.msdn.com/xmlteam/archive/2006/09/05/741251.aspx
”
XML Tools team has released the XSLT Profiler Addin for VS 2008 – a quick and reliable performance analysis profiler tool that assists in the development and debugging of XSLT documents. The XSLT Profiler Addin for VS 2008 allows developers to measure, evaluate, and target performance-related problems in XSLT code by creating detailed XSLT performance reports. The XSLT Profiler includes a wealth of useful hints for XSL and XSLT style sheet optimizations, which are essential for XSLT-based applications that demand maximum performance.
If you need to develop reliable and robust software, the XSLT Profiler is capable of detecting the performance errors and defects in coding so that they are corrected at an early stage in the development. This is essential in reducing the overall cost of developing software applications. The XSLT Profiler tool is fully integrated into Microsoft Visual Studio 2008 to provide a seamless and approachable user experience, combining several Microsoft technologies, including Microsoft XML Editor and XSLT Debugger, Visual Studio Team System, F1 (Performance Suites), and more.
For more information and download check out Microsoft Downloads site.”
see: http://blogs.msdn.com/xmlteam/archive/2008/02/07/announcing-the-xslt-profiler-addin-for-vs-2008.aspx
Good article, the full post is long but relevant if you use MSXML, however the basic summary is below:
Ideally, customers should standardize on MSXML6, but as mentioned above legacy applications or zero-deployment requirements may block full migration to MSXML6 in the short run. In this case there are two tensions that need to be balanced – functionality and test costs. This essentially leads to two options:
if (Web.Application.get_type() == Web.ApplicationType.InternetExplorer) {
var progIDs = [ ‘Msxml2.DOMDocument.6.0’, ‘Msxml2.DOMDocument.3.0’];
for (var i = 0; i < progIDs.length; i++) {
try {
var xmlDOM = new ActiveXObject(progIDs[i]);
return xmlDOM;
}
catch (ex) {
}
}
return null;
}
“tooling support offered in Visual Studio 2008 that will make working with XML easier. It will cover editing XML files, working with XML schemas, debugging XSLT style sheets and extending Visual Studio by writing your own custom XML Designers.”
see http://www.code-magazine.com/Article.aspx?quickid=0712162
http://blogs.parivedasolutions.com/borrell/archive/2007/05/19/MSBuildMultipleDeployments.aspx
http://borrell.parivedasolutions.com/2007/05/msbuild-copy-files-to-multiple-folders.html
http://blogs.msdn.com/msbuild/archive/2005/11/07/490068.aspx
http://www.sedodream.com/PermaLink,guid,8f6bbb30-ec22-4fc6-90a1-c32715598d23.aspx
“By way of explaination, TFS Deployer interfaces the Team Foundation Server build store with PowerShell allowing script execution to be triggered across multiple machines when a user transitions the quality indicator of a build from one state to another.”
VS Database Edition is Part of Team edition as well. check out the features here via video:
http://www.microsoft.com/web/content.aspx?id=visual-studio-2008-database
 |
Consider security and performance. |
|
Partition your application logically. |
|
Evaluate affinity. |
|
Reduce round trips. |
|
Avoid blocking on long-running tasks. |
|
Use caching. |
|
Avoid unnecessary exceptions. |
|
Tune the thread pool by using the formula to reduce contention. |
|
Consider minIoThreads and minWorkerThreads for burst load. |
|
Do not create threads on a per-request basis. |
|
Avoid blocking threads. |
|
Avoid asynchronous calls unless you have additional parallel work. |
|
Pool resources. |
|
Explicitly call Close or Dispose on resources you open. |
|
Do not cache or block on pooled resources. |
|
Know your application allocation pattern. |
|
Obtain resources late and release them early. |
|
Avoid per-request impersonation. |
|
Trim your page size. |
|
Enable buffering. |
|
Use Page.IsPostBack to minimize redundant processing. |
|
Partition page content to improve caching efficiency and reduce rendering. |
|
Ensure pages are batch compiled. |
|
Ensure debug is set to false. |
|
Optimize expensive loops. |
|
Consider using Server.Transfer instead of Response.Redirect. |
|
Use client-side validation. |
|
Identify the use of view state in your server controls. |
|
Use server controls where appropriate. |
|
Avoid creating deep hierarchies of controls. |
|
Avoid using Page.DataBind. |
|
Minimize calls to DataBinder.Eval. |
|
Separate dynamic data from static data in your pages. |
|
Configure the memory limit. |
|
Cache the right data. |
|
Refresh your cache appropriately. |
|
Cache the appropriate form of data. |
|
Use output caching to cache relatively static pages. |
|
Choose the right cache location. |
|
Use VaryBy attributes for selective caching. |
|
Use kernel caching on Microsoft® Windows Server™ 2003. |
|
Store simple state on the client where possible. |
|
Consider serialization costs. |
|
Use static properties instead of the Application object to store application state. |
|
Use application state to share static, read-only data. |
|
Do not store single-threaded apartment (STA) COM objects in application state. |
|
Prefer basic types to reduce serialization costs. |
|
Disable session state if you do not use it. |
|
Avoid storing STA COM objects in session state. |
|
Use the ReadOnly attribute when you can. |
|
Disable view state if you do not need it. |
|
Minimize the number of objects you store in view state. |
|
Determine the size of your view state. |
|
Avoid long-running and blocking calls in pipeline code. |
|
Consider asynchronous events. |
|
Use Response.Write for formatting output. |
|
Use StringBuilder for temporary buffers. |
|
Use HtmlTextWriter when building custom controls. |
|
Implement a Global.asax error handler. |
|
Monitor application exceptions. |
|
Use try/finally on disposable resources. |
|
Write code that avoids exceptions. |
|
Set timeouts aggressively. |
|
Use ASPCOMPAT to call STA COM objects. |
|
Avoid storing COM objects in session state or application state. |
|
Avoid storing STA components in session state. |
|
Do not create STA components in a page constructor. |
|
Supplement classic ASP Server.CreateObject with early binding. |
|
Use paging for large result sets. |
|
Use a DataReader for fast and efficient data binding. |
|
Prevent users from requesting too much data. |
|
Consider caching data. |
|
Constrain unwanted Web server traffic. |
|
Turn off authentication for anonymous access. |
|
Validate user input on the client. |
|
Avoid per-request impersonation. |
|
Avoid caching sensitive data. |
|
Segregate secure and non-secure content. |
|
Only use Secure Sockets Layer (SSL) for pages that require it. |
|
Use absolute URLs for navigation. |
|
Consider using SSL hardware to offload SSL processing. |
|
Tune SSL timeout to avoid SSL session expiration. |
|
Avoid unnecessary process hops. |
|
Understand the performance implications of a remote middle tier. |
|
Short-circuit the HTTP pipeline. |
|
Configure the memory limit. |
|
Disable tracing and debugging. |
|
Ensure content updates do not cause additional assemblies to be loaded. |
|
Avoid XCOPY under heavy load. |
|
Consider precompiling pages. |
|
Consider Web garden configuration. |
|
Consider using HTTP compression. |
|
Consider using perimeter caching. |
”
Copy Code<system.web>
<processModel autoConfig="true" />
</system.web>
”
The Feature Pack provides several exciting features for C++ developers, such as a major update to MFC and an implementation of TR1. Using the included MFC components, developers can create applications with the “look & feel” of Microsoft’s most popular products – Microsoft Office, Visual Studio and Internet Explorer. New components include the Office 2007 Ribbon Bar, Visual Studio docking and auto hide windows, Vista theme support, “on the fly” menu and toolbar customization, Shell management classes and much more. Our implementation of TR1 contains a number of important features such as smart pointers, regular expression parsing, containers (tuple, array, unordered set, etc) and sophisticated random number generators.
This product is a freely available download to any Visual Studio 2008 Standard or above customer and is fully covered under Microsoft’s standard support policies.
You may also want to take a look at the online documentation and walkthroughs for both MFC and TR1. The MFC documentation provides some great content to get you up and running quickly with the new components. “
see:
http://blogs.msdn.com/somasegar/archive/2008/04/07/visual-c-2008-feature-pack-shipped.aspx
Scott Gu has posted about a new free ASP.Net 3.5 Charting Control that you can downlaod from:
It looks pretty good:
See:
Drools.NET is a Business Rules Engine (BRE) based on Charles Forgy’s Rete algorithm. Developers can now exploit a powerful Rule Engine through a completely managed .NET code base. Drools.NET is based on Jboss Rules, and comes with all the features of that Rules Engine.
Drools can be used in place of the WWF rules engine if required.
below is from: http://webborg.blogspot.com/2008/07/couple-of-useful-javascript-global.html
”
L_Menu_BaseUrl – the base URL of the site / subsite. Very useful when you need to determine the absolute path of the site in JavaScript. Example: document.location = L_Menu_BaseUrl + ‘lists/calendar/allitems.aspx’ //redirects to Calendar list
L_Menu_LCID – the LCID of the site you’re in. Useful if you need to determine the language of the site. The list of Locale IDs can be found here. I’m using the LCID for localizations in ERTE project. See the example of checking LCID below:
.
L_Menu_SiteTheme – the name of the theme applied to the site.
There is one more useful variable, but this one can’t be used on custom master pages that you created. This one is used in the SharePoint’s default pages:
_spUserId – the ID of the logged in user.
“
Some downloads come in the for of a single .iso or .img file.
Common utilities for writing ISO file to recordable media such as DVD-R include Nero, and Roxio. The contents of image files can be used as virtual discs using utilities such as ISObuster, Daemon Tools or Virtual CloneDrive for Windows Vista
<xsl:value-of select=”DisplayUrl” />
with:
<xsl:value-of select=”concat(substring-before(DisplayUrl,’:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=’),’:8090/wi.aspx?id=’,substring-after(DisplayUrl,’artifactMoniker=’))” />
The bold printed 8090 is the port where you installed TSWA at.
If you now get a new notification e-mail and click on the link you’ll see the following much nicer work item details form provided by TSWA:
From the contents:
- Team Foundation Server Extensibility
- Team Foundation Server SDK Architecture
- How to: Run Team Foundation Server SDK Samples
- Team Foundation Core Services
- Work Item Tracking Extensibility
- Source Control Extensibility
- Data Warehouse Extensibility
- Reference for Team Foundation Server SDK
Link: http://msdn2.microsoft.com/en-us/library/bb130146(VS.80).aspx
“Everyday, we look at dozens of websites. The structure of these websites is defined in HTML, the lingua franca for publishing information on the web. Your browser’s job is to render the HTML according to the specs (most of the time, at least). You can look at the code behind any website by selecting the “View source” tab somewhere in your browser’s menu.
HTML consists of so-called tags, like the A tag for links, IMG tag for images and so on. Since tags are nested in other tags, they are arranged in a hierarchical manner, and that hierarchy can be represented as a graph. I’ve written a little app that visualizes such a graph, and here are some screenshots of websites that I often look at.”
An article by Microsoft, covers some the high-level information on migrating from SQL 2000 to 2005
http://www.microsoft.com/technet/prodtechnol/sql/2005/sqlupgrd.mspx
In particular the following section was useful for me:
The database engine upgrade is the easiest upgrade and will result in immediate return on investment in the areas of management, performance, and high availability. Again, the two main options for the database engine upgrade are side-by-side migration (in which you install the SQL Server 2005 engine as a secondary instance on the same server as your SQL Server 2000 or 7.0 server or on a completely separate server) and an in-place upgrade (in which you upgrade an instance of SQL Server 2000 or 7.0 through the install process and databases and other objects are upgraded “in place”).
With a side-by-side migration, the most common upgrade path is a simple database detach and re-attach on the SQL Server 2005 instance or a database backup and restore from the older version to the new version. If you keep an up-to-date version of your metadata scripts, you can also create the objects on the SQL Server 2005 server and use BCP to export and import your data. The other option is an in-place upgrade, in which you upgrade and adapt the databases, settings, and extended features to the SQL Server 2005 engine during the install process. When you run the setup process on a server that has a SQL Server 2000 or 7.0 instance, you’ll see an option to upgrade the selected instance to SQL Server 2005.
Note that for the database engine upgrade, all your existing Microsoft Data Access Components (MDAC) and ADO.NET applications will continue to function as when they were running against SQL Server 2000 or 7.0. In fact, SQL Server 2005 doesn’t come with a newer release of MDAC. But new to the platform is the SQL Native Client, combining an updated SQL ODBC driver and SQL OLEDB provider with network libraries in a single DLL. The SQL Native Client lets you leverage SQL Server 2005’s new client-access features, such as Multiple Active Result Sets (MARS), the XML data type, and user-defined types (UDTs). SQL Server comes with tight integration with the .NET Framework 2.0, which includes the latest ADO.NET version.
The in-place server upgrade will be the easiest. Although this approach requires a more thorough fallback plan and testing, you reap the rewards through seamless connectivity. By performing an in-place upgrade, logins and users remain in-sync, database connections remain the same for applications, and SQL Agent jobs and other functionality is concurrently upgraded during the installation. Note that several features, such as log shipping, replication, and cluster environments, have special upgrade considerations.
As noted earlier, for the database engine, the upgrade sets the compatibility mode to 8.0. You might benefit from leaving this setting at 8.0 under certain circumstances, such as for T-SQL references that are no longer supported in SQL Server 2005. I’ve run across some query hints that require rewriting, for example, as well as some legacy ANSI join syntax that’s being phased out (the *= left outer join syntax in particular). The analysis phase of your upgrade will uncover situations where using a lower compatibility setting might apply. However, I recommend that you fix any syntax that requires a lower compatibility level than 9.0 (SQL Server 2005) during the upgrade process. By reworking the syntax, your developers will have immediate access to all the new programming enhancements and features in the release. One quick trick to isolating these type issues and other syntax that might cause upgrade trouble is to script out the objects and procedures from the earlier platform version and attempt to run the scripts within SQL Server 2005. A simple attach or restore might suppress these issues. Also remember that some SQL logic can be embedded in your application. For data validation, running DBCC checkdb on your attached or restored database will confirm the integrity of the migrated data.
One caution: You probably have developers who are adept at leveraging system objects to make their lives easier. Microsoft has always told us to use Information_Schema views to get various metadata instead of querying the system tables directly because Microsoft can’t guarantee that the underlying object structure will persist in new platforms. With the new release, Microsoft has changed SQL Server’s underlying object structure. Also note that SQL Server 2005 catalog views and Dynamic Management Views (DMVs) have restricted permissions. PUBLIC users no longer have permissions to view catalog views, and users with GUEST/PUBLIC permissions can’t select from DMVs.
VS 2008 fully supports building applications for .NET Framework 2.0… This is very important as it will take time for some hosters and IT organizations to fully deploy .NET Framework 3.5, but you don’t want that to block you from taking full advantage of the cool features in VS 2008.
Today we released ASP.NET 2.0 AJAX Templates for VS2008. This release contains project templates for using Visual Studio 2008 or Visual Web Developer 2008 to create new web sites and web applications with ASP.NET AJAX Extensions features. The project templates contain specific references to assemblies in .NET Framework 2.0 and ASP.NET 2.0 AJAX Extensions 1.0.
Download the ASP.NET 2.0 AJAX Templates for VS2008!
To try these out, make sure you have ASP.NET AJAX Extensions installed, then install the ASP.NET AJAX Templates for Visual Studio 2008.
Then, go to File->New Project and select .NET Framework 2.0 as the target runtime. That will filter down the options and you should see “AJAX 1.0-Enabled ASP.NET 2.0 Web Application”. Select it.
Notice the assembly reference in web.config is fixed up to be the 1.0 version number…
<system.web> <pages> <controls> <add tagPrefix="asp" namespace="System.Web.UI" assembly="System.Web.Extensions, Version=1.0.61025.0, ... </controls> </pages>
Using the rules engines’ chaining behaviour it’s possible to loop through a collection of items and execute a rule for each item in the collection.
E.g. I created a spam filter that uses the rules engine to check for keywords in an email. Instead of creating a separate rule for each keyword you can just store all the keywords in a collection and use the chaining behaviour of the rules engine to loop through the collection executing a rule for each keyword.
To do this i followed a pattern taken from MSDN: Processing Collections In Rules
THEN …
In my spam filter example I had 4 rules which did the following:
With .Net 3.0 or later there is the ‘Windows Workflow Foundation’ which includes the Rules Engine.
Using the rules engine you can create an external set of rules and execute them against any .Net object.
from http://blogs.microsoft.co.il/blogs/bursteg/archive/2006/10/11/RuleExecutionWithoutWorkflow.aspx
Create a RuleSet
The RuleSet Editor Dialog is exposed as part of the API, so you can use it to create RuleSets as part of your program:
// Create a RuleSet that waorks with Orders (just another .net Object)
RuleSetDialog ruleSetDialog = new RuleSetDialog(typeof(Order), null, null);
// Show the RuleSet Editor
ruleSetDialog.ShowDialog();
// Get the RuleSet after editing
RuleSet ruleSet = ruleSetDialog.RuleSet;
Serialize and Deserialize rules
Windows Workflow Foundation uses the WorkflowMarkupSerializer to Serialize and Deserialize rules.
// Serialize to a .rules file
WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
XmlWriter rulesWriter = XmlWriter.Create(fileName);
serializer.Serialize(rulesWriter, ruleSet);
rulesWriter.Close();
// Deserialize from a .rules file.
XmlTextReader rulesReader = new XmlTextReader(fileName);
WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
ruleSet = (RuleSet)serializer.Deserialize(rulesReader);
rulesReader.Close();
Execute RuleSet againt an object
Execute your RuleSet after editing, serializing and deserialising it, but first validate that the rules can be executed against the input object.
// Execute the rules and print the entity’s properties
Order myOrder = new Order(…);
RuleValidation validation = new RuleValidation(typeof(Order), null);
RuleExecution execution = new RuleExecution(validation, myOrder);
ruleSet.Execute(execution);
An Introduction to WWF and rules engine is available here:
http://msdn2.microsoft.com/en-gb/library/aa480193.aspx
includes useful information about chainging:
Each rule in a RuleSet has a priority value with a default of 0. The rules in a RuleSet can be considered a sorted collection, ordered by the priority values. The WF Rules evaluator evaluates rules individually and executes the rule’s actions based on the results of the rule’s condition evaluation
A selection of examples are available from
http://wf.netfx3.com/files/folders/rules_samples/entry309.aspx
Flajaxian FileUploader is .NET web control designed for asynchronous file upload of multiple files at the same time, without a page post back and with a progress bar indicating the current upload progress. This control does not require full trust environment. The control can be extended with the addition of server side and client side adapters. Flajaxian FileUploader uses Adobe Flash Player 8 or higher Flash player for the file upload.
SQL Server requires (READ) locks for reading from the database (select queries).
For Updates (WRITE) locks are used.
SQL Server starts with row-level locks, but often escalates these to page and table locks, causing deadlocks.
Using NOLOCK tells SQL Server to ignore locks and read directly from the tables. This means you don’t have to worry about locks, however you may read data that is not yet committed (i.e. in the Process of being updated, and not yet committed, or worse yet was int he process of being updated, but then the transaction doing the writing rolls back, so you read data that was never there). Obviously only use NOLOCK when you can deal with these consequences (e.g. it might not be a good idea in an Accouting system, but may be fine for a CMS style site).
Using ROWLOCK, means that the lock type won’t esclated up to page or table locks (which would have effected more records than just those being updated). Instead locks will always be at the ROW level.
Examples:
SELECT Name
FROM Person WITH (NOLOCK)
WHERE Name LIKE ‘Smith’
and
UPDATE Person WITH (ROWLOCK)
SET Name = ‘Albert’ WHERE Name= ‘Bert’
Interesting article on connecting to Mainframe apps via Biztalk/.Net:
SmartPart is a SharePoint web part which can host any ASP.NET web user control. The project is on codeplex:
http://www.codeplex.com/smartpart
example:
There is an open source project on codeplex that provides a connector between ProjectServer and TFS. We are big users of TFS and are thinking about extending our PM function with ProjectServer so this could be very useful going forwards.
VS2008 SP1 supports JQuery intellisense. We are using JQuery a bit, the JSONP support is really good and helps us with our cross domain scripting.
Re intellisense see:
http://weblogs.asp.net/scottgu/archive/2008/09/28/jquery-and-microsoft.aspx
“Uploading images to a Wiki might seem like a simple operation, but there are a few tricks to remember.
Once you have created the image library for the images that you want in your wiki, navigate to your wiki page and click the image icon.
You’ll be asked to provide alternate text and the URL. Use the full path to your image, which will be something like ‘http://sharepoint/sites/<site name>/<name of image library>/<name of image>.jpg. It will vary depending on how your administrator has set up the original path (the stuff before <site name>). Confused about the path to your image? You can view the path by right clicking on the image and selecting Properties. There may be extra characters in there. Ignore them, those _t’s and others.”
“The ability to branch and merge source code with Visual Studio Team Foundation Server can really enable a team to build software in a more agile and maintainable manner. But choosing the best branching strategy can be a bit overwhelming at first. In this interview we ask Doug Neumann, Group Program Manager for Team Foundation Server, to give us a Branching and Merging primer.” (from MS channel 9)
see the video guidance: http://channel9.msdn.com/posts/Rory/Branching-101-with-Doug-Neumann-Visual-Studio-Team-Foundation-Server/
I have a soft spot for Mono having used it a bit a few years ago (and first looking at it in 2001). Anyway a lot of progress has been made. Great for writing .Net apps in a MAC or Linux world:
John BouAntoun has posted about Mono going to Version 2 with ASP.Net 2 support as well as C#3.0
All HTTP load balancers support “sticky sessions”: Requests in the same session must be forwarded to the same server node unless there is a failover. You must turn on sticky sessions in your setup. In an ideal world, all nodes in a replicated cluster have the same state; thus, the load balancer can forward any request to any node. But in a real cluster, the network and CPU resources are limited. It takes time to actually replicate the state from node to node. Without sticky sessions, the user gets random HTTP 500 errors when the request hits a node that does not yet have the latest replicated state.
fromjboss doco with some minor editing on my part to keep it just at the concept level.
Interesting guide/checklist if your looking to do a security review for your ASP.Net deployments:
“This How To shows you how to perform a security deployment review for an ASP.NET 2.0 application to identify potential security vulnerabilities introduced by inappropriate configuration settings. The majority of the review process involves making sure that correct configuration settings are applied to the machine-level Web.config file and your application-specific Web.config file.
”
see:
http://www.guidanceshare.com/wiki/How_To:_Perform_a_Security_Deployment_Review_for_ASP.NET_2.0
In mid Oct 2008 Silverlight 2 was fully and offically released. see:
http://weblogs.asp.net/scottgu/archive/2008/10/14/silverlight-2-released.aspx
As of .NET 4.0, LINQ to Entities will be the recommended data access solution for LINQ to relational scenarios, as opposed to Linq2Sql
Interesting for us as we use Linq2Sql in some cases so we will change our raodmap.
See:
http://blogs.msdn.com/adonet/archive/2008/10/31/clarifying-the-message-on-l2s-futures.aspx
SQL Server 2008 has intellisense built in.
If you need intellisense for SQL Server 2005 you can use a 3rd party product from Redgate called ‘SQL Prompt’ an example is below:
Scott Hansleman has an interesting post on deploying ASP.Net MVC on .Net 2 (normally .Net 3.5 sp1 is required), although I am not sure if I would do it in production:
http://www.hanselman.com/blog/DeployingASPNETMVCOnASPNET20.aspx
“This TFS Custom control for Work Items (requires SP1) allows setting a parent work item, displays parent work item as well as a child hierarchy and prevents closing a parent when any child work items are not closed.”
An initial implementation, capable of executing simple WIQL queries against the Work Item Store of a TFS server:
Early stages, but there is a release, and it could be a useful base to start from:
customise and edit work items and process templates (add/edit fields):
First get the workitem in code (as per TFS code samples) then:
foreach(Revision rev in wrkitem.Revisions)
{
foreach(Field f in rev.Fields)
{
Console.WriteLine(“{0} = {1}\n”,f.Name,f.Value);
}
}
There is also the OriginalValue property on fields as an alternative (for some styles of history access):
foreach(Field f in rev.Fields)
{
if(!Object.Equals(f.Value, f.OriginalValue))
{
Console.WriteLine(“{0}: {1} -> {2}”, f.Name, f.OriginalValue, f.Value);
}
}
DylanSmith had an interesting forum comment on the SFTS website
He tracks actual time using the SFTS template through appropriate use of the Estimated Effort and Work Remaining fields. The idea is that if you want to enter X hours of actual time against a SBI you have to decrease the Work Remaining by Y and/or increase the Estimated Effort by Z such that Y+Z == X.
For example, lets say I had an SBI with an Estimated Effort (EE) of 5 hours, and a Work Remaining (WR) of 5 hours.
Day 1: Actual time spent on SBI is 3 hours. Change WR to 2. (Y = 3, Z = 0, Y+Z = 3).
Day 2: Actual time spent on SBI is 3 more hours, and I’m still not complete, probably about 1.5 hours remaining still on this SBI. Change WR to 1.5, Change EE to 7.5 (Y = 0.5, Z = 2.5, Y+Z = 3).
Using this method I can report on actual time, it is simply EE – WR.
from the SfTS website:
Here are some standard reasons why the reports do not appear to work:
from the MSDN doco:
“The Execute Process task runs an application or batch file as part of a SQL Server 2005 Integration Services (SSIS) package workflow. Although you can use the Execute Process task to open any standard application, such as Microsoft Excel or Microsoft Word, you typically use it to run business applications or batch files that work against a data source. For example, you can use the Execute Process task to expand a compressed text file. Then the package can use the text file as a data source for the data flow in the package. As another example, you can use the Execute Process task to run a custom Visual Basic application that generates a daily sales report. Then you can attach the report to a Send Mail task and forward the report to a distribution list.
When the Execute Process task runs a command-line application, it provides input to the application through a variable that you specify in a property setting. The Execute Process task also includes properties for specifying the variables that consume the standard output and error output of the application. For more information about variables, see Integration Services Variables and Using Variables in Packages.
The Execute Process task can specify the command prompt arguments that the executable file or batch file requires. For example, if the task opens a document in Word, the command prompt argument can name the .doc file. You can use multiple command arguments in one task by using spaces to delimit arguments.
Additionally, you can configure the Execute Process task to specify a working directory, a time-out period, or a value to indicate that the executable ran successfully. The task can also be configured to fail if the return code of the executable does not match the value that indicates success, or if the executable is not found at the specified location.”
see: http://msdn.microsoft.com/en-us/library/ms141166(SQL.90).aspx
great blog post in this link, some really interesting stuff:
http://www.databasejournal.com/features/mssql/article.php/3552621
Quote from the Article:
”
Probably the most common data processing scenario in which WMI events could be helpful, involve launching a sequence of tasks activities as soon as data to be processed becomes available (e.g. by being copied to target computer). This can be accomplished by employing a SELECT query against __InstanceCreationEvent class in combination with another class, for which creation of a new instance is equivalent to creation of a new file on a managed computer. The best match in this case (from the performance point of view) is the CIM_DirectoryContainsFile class (this class forms an association between CIM_Directory and CIM_File classes, which are referenced as its GroupComponent and PartComponent properties, respectively). In order to detect a new file appearing in a specific directory (in our example c:\Data), you would run the following query (note that the last entry contains extra backslashes as so-called escape characters, which ensure proper string parsing. Such characters need to be applied whenever you want the next character to be treated literally. For example, by placing it after "Win32_Directory.Name=\, you ensure that the following double quote does not indicate the end of this string, but rather the beginning of the path to target folder c:\Data. Similarly, we added it in front of each backslash appearing in the folder path):
SELECT * FROM __InstanceCreationEvent WITHIN 10
WHERE TargetInstance ISA "CIM_DirectoryContainsFile"
AND TargetInstance.GroupComponent = "Win32_Directory.Name=\"c:\\\\Data\""
Now it is time to look into incorporating this functionality into SSIS packages using the WMI Event Watcher Task. Start by creating a new project using SQL Server Business Intelligence Development Studio. Drag the WMI Event Watcher Task from the toolbox onto the Control Flow area of the package designer interface. Right-click on it and select Edit option from the context sensitive menu. In the resulting WMI Event Watcher Task Editor window, switch to the WMI Options entry.
“
1) File.Exists(path) call Script Task
2) ForEach File Enumerator see: http://www.sqlis.com/post/Looping-over-files-with-the-Foreach-Loop.aspx
3) File Watcher Task see: http://www.sqlis.com/post/File-Watcher-Task.aspx
from: http://blogs.conchango.com/jamiethomson/archive/2005/11/02/2341.aspx
Very interesting post, quoted below, gets around some deployment issues:
“Recently I have been using the SSIS Script Task and Script Component quite heavily. For those that don’t know, these items use Visual Studio for Applications (VSA) under the covers.
There is a peculiar limitation of VSA that requires you to place any DLLs that you want to reference into the Microsoft.Net\Framework folder of your machine – it isn’t enough to GAC it.
Happily this only needs to be done on development machines because this is a design-time requirement. When the VSA apps run they use DLLs in the GAC – they don’t need to be in the Microsoft.Net\Framework folder. Or so it seems to me anyway. To prove this I changed the name of my DLL in the Microsoft.Net\Framework folder and sure enough I got design-time errors but my packages containing script tasks/components that referenced that DLL still ran successfully. One caveat – this will only work if the script is pre-compiled – so make sure the PreCompile setting on your script task/component is set to TRUE.“
To call a C# assembly from an SSIS Task you need to do the following:
1- Build the C# with strong naming ( SDK Command :>sn /K c:\key.snk, add the Key.snk to the project and use it to sign it)
2- Add the Assembly to the CAG (VS Command:>gacutil /i AssemblyName.dll)
3- Copy the assembly to the “C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727″ folder for the Develpment or Production server
4- Form the SSIS Script designer, add the reference as it should appear in the list.
5- Import the library and instentiate an object to be used for the task
from: http://oassaf.wordpress.com/2007/05/24/calling-c-assembly-from-ssis-script-task/
Using the TFS power toys, and ‘Work Item Templates’ you can do bulk updates of work items in TFS.
FRom EA site:
Enterprise Architect provides a comprehensive project estimation tool that calculates effort from use case and actor objects, coupled with project configurations defining the complexity of the work environment. This method is based on Karner’s Use Case Points Method, with several variations noted below. You can also produce a metrics report containing the project estimation analysis to incorporate into your project documentation. An example is here.
Before estimating project size, you will first need to configure the technical and environmental factors (see menu item Configuration – Metrics and Estimation Types – TCF and ECF values). For both TCF (technical complexity factor) and ECF (environment complexity factor), an editable table contains a list of factors influencing project productivity. A weight is associated with each factor, reflecting how much that factor relatively affects productivity; a weight is irrelative to a project. The supplied factors and their associated weights are defined by the Use Case Points Method, although they may be adjusted to suit a project’s specific needs. For most purposes, the only table column needing adjustment will be ‘Value’, which indicates the degree of influence a particular factor holds over the project. As a suggested gage, a value of ‘0’ indicates no influence, a ‘3’ indicates average influence, and a ‘5’ indicates strong influence.
Karner’s UCP method also calculates project effort by considering project actors, and their contributing complexity. There is an option to include actors in the estimation calculation; by default, only use cases are considered. If project actors are also included, make sure their complexity has been assigned by some method; rough guidelines to this assignment are supplied below:
Once you have set up the use cases, actors and environment, highlight the package in the project browser whose contents you would like to estimate; for the entire project, select the root view. Next, select Project – Use Case Metrics from the menu. The following screen will appear:
UCMetrics
Some interesting info on the next version of TFS, which will make hierarachical work item management easier:
TFS Hierarchical Work Items
A Senior PM from work put me onto ExtJS which is a useful looking active style js ajax library.
It includes:
In TFS 2008, there’s a capability to delete unused work item via a command line tool (TFPT.EXE) provided by the TFS 2008 Power Tools.
See following: http://www.bappedyanto.com/post/Delete-Work-Item-in-TFS.aspx
From http://www.packtpub.com/article/jquery-table-manipulation-part2
Check out the link for more details and more complex examples.
Can be as simple as two lines of code to alternate the background color:
$(document).ready(function() {
$(‘table.sortable tbody tr:odd’).addClass(‘odd’);
$(‘table.sortable tbody tr:even’).addClass(‘even’);
});
If we declare background colors for the odd and even classes as follows, we can see the rows in alternating shades of gray:
tr.even {
background-color: #eee;
}
tr.odd {
background-color: #ddd;
}
We were upgrading some old servers which had previously had .Net 1.1 and 2.0 to .net 3.5 and ran into some troubles.
The following blog post had some helpful info:
http://blogs.msdn.com/astebner/archive/2008/03/07/8108332.aspx
from http://weblogs.asp.net/ashben/archive/2003/10/14/31773.aspx
“The .NET FileSystemWatcher class makes it possible to quickly and easily launch business processes when certain files or directories are created, modified, or deleted. The FileSystemWatcher class, for example, can be quite useful in application integration, by way of monitoring incoming data files and processing it once an event is raised. It listens to the file system change notifications and raises events when a directory, or file(s) in a directory, changes. The component can watch files on a local computer, a network drive, or a remote computer.
I’ve come to realize that it does need some understanding of this class to make it work efficiently. For example, a denial-of-service attack is possible if a malicious program gains access to a directory the FileSystemWatcher component is monitoring, and which thereby generates so many changes that the component cannot manage them and can cause a buffer overflow or other drastic effects. Following are some tips and notes on how to use the FileSystemWatcher class to build a more robust solution:
1. Events being raised twice – An event will be raised twice if an event handler (AddHander FSW.Created, AddressOf FSW_Created) is explicitly specified. This is because, by default, the public events automatically call the respective protected methods (OnChanged, OnCreated, OnDeleted, OnRenamed). To correct this problem, simply remove the explicit event handler (AddHandler …).
2. Events being raised multiple times – In some cases a single event can generate multiple events that are handled by the component. Because FileSystemWatcher monitors the operating system activities, all events that applications fire will be picked up. For example, when a file is moved from one directory to another, several OnChanged and some OnCreated and OnDeleted events might be raised. Moving a file is a complex operation that consists of multiple simple operations, therefore raising multiple events. Such multiple events can be correctly handled and processed by using a simple boolean flag check (for a first-come-first-serve approach) or by setting the FileSystemWatcher.NotifyFilter property to one of the NotifyFilters values.
3. Thread Safety – Any public static (Shared in VB) members of this class type are thread safe. Any instance members are not guaranteed to be thread safe.
4. File System Type – The FileSystemWatcher does not raise events for CDs and DVDs, because time stamps and properties cannot change for such media types.
5. Filter – The Filter property can be used to watch for changes in a certain type(s) of file(s) (eg: “*.txt”). To watch for changes in all files, set the Filter property to an empty string (“”). Hidden files are also monitored by the FileSystemWatcher.
6. Internal Buffer – The FileSytemWatcher component uses an internal buffer to keep track of file system actions. You should set the buffer to an appropriate size for the approximate number of events you expect to receive. By default, the buffer is set to a size of 4 KB. A 4 KB buffer can track changes on approximately 80 files in a directory. Each event takes up 16 bytes in the buffer, plus enough bytes to store the name of the file, in Unicode (2 bytes per character), that the event occurred on. You can use this information to approximate the buffer size you will need. You (re)set the buffer size by setting the InternalBufferSize property. If there are many changes in a short time, the buffer can overflow. This causes the component to lose track of changes in the directory, and it will only provide blanket notification. Increasing the size of the buffer is expensive, as it comes from non-paged memory that cannot be swapped out to disk, so keep the buffer as small as possible. Setting the Filter does not decrease what goes into the buffer. If you are using Microsoft Windows 2000, you should increase the buffer size in increments of 4 KB, because this corresponds to the operating system’s default page size. With any other operating system, you should increase the buffer size in increments that correspond to the operating system’s default page size. If you are unsure of the default page size for the operating system you are using, the safest way to proceed is to just double the original size of the buffer. This will maintain the original interval needed for your operating system.
7. Directories – Changing a file within a directory you are monitoring with a FileSystemWatcher component generates not only a Changed event on the file but also a similar event for the directory itself. This is because the directory maintains several types of information for each file it contains – the names and sizes of files, their modification dates, attributes, and so on. Use the IncludeSubdirectories property to indicate whether or not you want to include the subdirectories of the directory you are watching. If you turn this off when you do not need it, you will receive fewer events than when it is turned on.
8. Stop Watching – When file system monitoring is not needed anymore, you should set the EnableRaisingEvents property to False to disable the component, otherwise the component will continue listening.
The FileSystemWatcher class provides a useful feature but it should be implemented along with a thorough examination.”
Interesting post at (all content bleow taken from this link):
Taken from: http://www.codeguru.com/csharp/.net/net_general/tipstricks/article.php/c9113/
“An application I was working on that used the FileSystemWatcher class and was intended to run 24/7 would periodically stop working. After a little searching, I managed to narrow it down to network outages. You see, the watcher was looking at a network drive, and intermittently (as networks will) it was dropping out and then coming back again. I soon learnt that, when this happens, the FileSystemWatcher loses track of what it was supposed to do.
Easy to fix? Well, it’s not too hard. Check out the example below. You can even test this on your local machine by simply removing the directory that is being searched:”
namespace ConsoleApplication1
{
class Class1
{
private static FileSystemWatcher watcher =
new FileSystemWatcher();
[STAThread]
static void Main(string[] args)
{
WatchFile();
Console.ReadLine();
}
// set up the FileSystemWatcher object
private static void WatchFile()
{
// ***** Change this as required
watcher.Path = @”\\myServer\c$\test\”;
// For this example, I only care about when new files are
// created
watcher.NotifyFilter = NotifyFilters.LastWrite;
watcher.Filter = “*.txt”;
// Add event handlers: 1 for the event raised when a file
// is created, and 1 for when it detects an error.
watcher.Changed += new FileSystemEventHandler(NewFile);
watcher.Error += new ErrorEventHandler(WatcherError);
// Begin watching.
watcher.EnableRaisingEvents = true;
}
// Define the found event handler.
private static void NewFile(object source, FileSystemEventArgs e)
{
Console.WriteLine(“A file has been found!”);
File.Delete(e.FullPath);
}
// The error event handler
private static void WatcherError(object source, ErrorEventArgs e)
{
Exception watchException = e.GetException();
MessageBox.Show(“A FileSystemWatcher error has occurred: ”
+ watchException.Message);
// We need to create new version of the object because the
// old one is now corrupted
watcher = new FileSystemWatcher();
while (!watcher.EnableRaisingEvents)
{
try
{
// This will throw an error at the
// watcher.NotifyFilter line if it can’t get the path.
WatchFile();
Console.WriteLine(“I’m Back!!”);
}
catch
{
// Sleep for a bit; otherwise, it takes a bit of
// processor time
System.Threading.Thread.Sleep(5000);
}
}
}
}
}
Eric Lee has an intersting post where he provides teh source code to an app that you can use to update your TFS Warehouse. Its at:
http://blogs.msdn.com/ericlee/archive/2006/07/09/660993.aspx
I am using TFS 2008 and if I delete a project using TFSDeleteProject.exe and recreate another with exactly the same name then all the TFS reports are blank. The solution is to not recreate the project with the same name (I tried rebuilding the warehosue but that did not seem to help in my case):
“The warehouse is a historical repository, and it will retain information about projects even after they are deleted from the operational stores.”
http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=187231&SiteID=1
To delete a TFS project, you can use teh command line tool TfsDeleteproject.exe which is normally found in ‘C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE’ directory.
Open a command promt, CD to that directory and then issue teh following command:
tfsdeleteproject /server:http://MyServer:8080 MyProjectName
Obviously change teh MyServer to be the name of your server and the MyProjectName to be the name of your project.
But if you do delete a project don’t recreate another project afterwards with the same name, I’ll cover why in another post.
From google:
To prevent robots from crawling your site, place the following robots.txt file in your server root:
User-agent: * Disallow: /
To remove your site from Google only and prevent just Googlebot from crawling your site in the future, place the following robots.txt file in your server root:
User-agent: Googlebot Disallow: /
Each port must have its own robots.txt file. In particular, if you serve content via both http and https, you’ll need a separate robots.txt file for each of these protocols. For example, to allow Googlebot to index all http pages but no https pages, you’d use the robots.txt files below.
For your http protocol (http://yourserver.com/robots.txt):
User-agent: * Allow: /
For the https protocol (https://yourserver.com/robots.txt):
User-agent: * Disallow: /
NB: if a robot discovers your site by other means –
for example, by following a link to your URL from another site – your
content may still appear in our index and our search results. To
entirely prevent a page from being added to the Google index even if
other sites link to it, use a noindex meta tag.
Normally firefox will pop up and ask you to view application/json as a file (like a file download). This can get annoying.
To view this in Firefox 3 Directly you can use ‘Open in Browser’ add in:
https://addons.mozilla.org/en-US/firefox/addon/8207
or the JSONovich is a Firefox extension that pretty-prints and colorizes JSON content.
http://lackoftalent.org/michael/blog/json-in-firefox/
To associate it with an external application directly you can use Firefox ‘MIME Edit’. It word with Firefox 2. You can get it from: https://addons.mozilla.org/en-US/firefox/addon/4498
You can do the same in IE without needing a tool by updating the Windows Registry as follows:
[HKEY_CLASSES_ROOT\MIME\Database\Content Type\application/json]
“CLSID”=”{25336920-03F9-11cf-8FD0-00AA00686F13}”
“Encoding”=hex:08,00,00,00
Further info at: http://msdn.microsoft.com/en-us/library/ms775148.aspx
Juval Lowy has an interesting article over on MSDN about building a queued WCF response.
http://msdn.microsoft.com/en-us/magazine/cc163482.aspx
“Windows Communication Foundation (WCF) enables disconnected work between clients and services. The client posts messages to a queue and the service processes them later. Such interaction permits a different programming model from the default request/response pattern, enabling possibilities such as load leveling, improved availability, and compensating work, to name just a few. This column starts with a brief introduction to Windows® Communication Foundation queued calls and then presents an interesting problem-how to get results out of a queued call-and the solution via some cool Windows Communication Foundation programming techniques and a few helper classes I wrote for this purpose.”
The WebOperationContext has a property called OutgoingResponse (which is of type OutgoingWebResponseContext) which in turn has a StatusCode property that you can set. WebOperationContext.Current is available for REST based WCF services in much the same way as HttpContext is available for ASMX/ASPX and ServiceContext is available for normal (non rest) WCF Services
WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.OK;
From the IE Mobile Team Weblog at:
http://blogs.msdn.com/iemobile/archive/2006/08/03/Detecting_IE_Mobile.aspx
“For Windows Mobile 5.0, the “current” release, the User-Agent header that the browser sends across is one of the following two strings:
Moving forward, here’s the new IE Mobile User-Agent string:
If you want to detect the current/older IE Mobile browsers, the way to do it is to look for “PPC” or “Smartphone“, as well as “Windows CE” in that string. That’s the only sure-fire way to be certain of what you’re getting.
If you want to detect the new browsers coming out, just look for the string “IEMobile” as part of the User-Agent header. Since the capabilities of the Pocket PC and Smartphone versions of the browser are identical, and they’re built from the identical code base, there’s no reason to differentiate them any more. “
Interesting article: http://channel9.msdn.com/wiki/mobiledeveloper/programmingwithinternetexplorermobileandajax/
“Ajax is a design model that has the aim of making web sites that are close to applications in terms of responsiveness and usability. Ajax applications are very suited to mobile devices, as they are lightweight, do not require any code to be installed on the device itself, and can be accessed remotely using the built-in (Internet Explorer Mobile) client that’s present on every device.”
The below is taken from: http://weblogs.asp.net/mdavey/pages/79456.aspx I came across it a few years ago and found it useful based on what i was doing at the time, I just found it again in my browser favourites so thought i would post it for the sake of completeness….
Tibco RV is often used in investment banks to send market data. Its therefore going to be a requirement for any front-office trading application running on Linux and Mono to subscribe to Tibco RV subjects. What follows is a simple example of the code required to do this – effectively a Mono language binding for Tibco RV. This code was written on RedHat 9.0, with Mono 0.30, and Tibco 7.2.
First we need a C++ library (.so) which uses the Tibco RV C++ API to setup a simple subscription. Callback’s from C++ to C# (unmanaged to managed) are handled by C++ function pointers and normal C# delegates. The C++ “Start” function below will be called by C#, passing a C# delegate, which the C++ will callback on when a message is received on the Tibco RV subject.
#include
#include
#include
#include
#include
#include “tibrv/tibrvcpp.h”
/*********************************************************************/
/* Transport parameters */
/*********************************************************************/
char* serviceStr = NULL;
char* networkStr = NULL;
char* daemonStr = “tcp::7500”;
typedef void (*stringFunction)(char*);
stringFunction stringFunctionPtr;
/*********************************************************************/
/* Message callback class */
/*********************************************************************/
class MsgCallback : public TibrvMsgCallback
{
public:
void onMsg(TibrvListener* listener, TibrvMsg& msg)
{
const char* sendSubject = NULL;
const char* replySubject = NULL;
const char* msgString = NULL;
// Get the subject name to which this message was sent
msg.getSendSubject(sendSubject);
// If there was a reply subject, get it
msg.getReplySubject(replySubject);
// Convert the incoming message to a string
msg.convertToString(msgString);
if (replySubject != NULL)
printf(“subject=%s, reply=%s, message=%s\n”, sendSubject, replySubject, msgString);
else
printf(“subject=%s, message=%s\n”, sendSubject, msgString);
printf(“About to do callback to C#\n”);
(*stringFunctionPtr)((char*)msgString);
fflush(stdout);
}
};
extern “C” void Start(stringFunction f)
{
stringFunctionPtr = f;
TibrvStatus status;
// open Tibrv
status = Tibrv::open();
if (status != TIBRV_OK)
{
fprintf(stderr,”Error: could not open TIB/RV, status=%d, text=%s\n”, (int)status,status.getText());
exit(-1);
}
// Create network transport
TibrvNetTransport transport;
status = transport.create(serviceStr,networkStr,daemonStr);
if (status != TIBRV_OK)
{
fprintf(stderr,”Error: could not create transport, status=%d, text=%s\n”, (int)status,status.getText());
Tibrv::close();
exit(-1);
}
transport.setDescription(“SomeSubject”);
TibrvListener* listener = new TibrvListener();
status=listener->create(Tibrv::defaultQueue(),new MsgCallback(),&transport,”SomeSubject”);
if (status != TIBRV_OK)
{
fprintf(stderr,”Error: could not create listener on %s, status=%d, text=%s\n”, “SomeSubject”,(int)status,status.getText());
Tibrv::close();
exit(-1);
}
printf(“Listening on: %s\n”,”SomeSubject”);
fflush(stdout);
// dispatch Tibrv events
while((status=Tibrv::defaultQueue()->dispatch()) == TIBRV_OK);
// if everything is Ok we’ll never get here
fprintf(stderr,”Error: dispatch failed, status=%d, text=%s\n”, (int)status,status.getText());
Tibrv::close();
exit(-1);
}
We use the DllImport .NET attribute to tell C# where the C++ “Start” method should be located. The TibCallback delegate must match the C++ function pointer stringFunction from an argument perspective.
using System;
using System.Threading;
using System.Runtime.InteropServices;
namespace Test
{
public delegate void TibCallback(string s);
public class Class1
{
[DllImport(“”, CharSet=CharSet.Ansi)]
public static extern void Start(Delegate d);
private Thread tibThread;
static void Main(string[] args)
{
new Class1().Run();
}
public void Run()
{
tibThread = new Thread(new ThreadStart(StartTib));
tibThread.IsBackground = true;
tibThread.Name = “TibThread”;
tibThread.Start();
Console.ReadLine();
}
private void StartTib()
{
Start(new TibCallback(this.TibMsg));
}
public void TibMsg(string s) {
Console.WriteLine(“TibMsg called”);
Console.WriteLine(s);
}
}
}
I have been taking a look at, and and keeping an eye on, processing for the last few years. It has been awesome for doing data visualisation stuff. So far I have really enjoyed it. Its based on top of java (which means you need a JVM in your browser), I wonder if anyone will make a Silverlight based version?
From the website: Processing is an open source programming language and environment for people who want to program images, animation, and interactions. It is used by students, artists, designers, researchers, and hobbyists for learning, prototyping, and production. It is created to teach fundamentals of computer programming within a visual context and to serve as a software sketchbook and professional production tool. Processing is an alternative to proprietary software tools in the same domain.
Daniel Shiffman has a good related blog. Really interested stuff, he takes it to next level as a platform for installation art. He is an Assistant Arts Professor at the Interactive Telecommunications Program at NYU’s Tisch School of the Arts his blog can be found at: http://www.shiffman.net/
I found this in my web travels, It was useful in a simple trading app demo I was working on. Pretty easy stuff, but useful anyway….
This sample code outputs values:
/// <summary>
/// Calculates a moving average value over a specified window. The window size must be specified
/// upon creation of this object.
/// </summary>
/// <remarks>Authored by Drew Noakes, February 2005. Use freely, though keep this message intact and
/// report any bugs to me. I also appreciate seeing extensions, or simply hearing that you're using
/// these classes. You may not copyright this work, though may use it in commercial/copyrighted works.
/// Happy coding.
///
/// Updated 29 March 2007. Added a Reset() method.</remarks>
public sealed class MovingAverageCalculator
{
private readonly int _windowSize;
private readonly float[] _values;
private int _nextValueIndex;
private float _sum;
private int _valuesIn;
/// <summary>
/// Create a new moving average calculator.
/// </summary>
/// <param name="windowSize">The maximum number of values to be considered
/// by this moving average calculation.</param>
/// <exception cref="ArgumentOutOfRangeException">If windowSize less than one.</exception>
public MovingAverageCalculator(int windowSize)
{
if (windowSize < 1)
throw new ArgumentOutOfRangeException("windowSize", windowSize, "Window size must be greater than zero.");
_windowSize = windowSize;
_values = new float[_windowSize];
Reset();
}
/// <summary>
/// Updates the moving average with its next value, and returns the updated average value.
/// When IsMature is true and NextValue is called, a previous value will 'fall out' of the
/// moving average.
/// </summary>
/// <param name="nextValue">The next value to be considered within the moving average.</param>
/// <returns>The updated moving average value.</returns>
/// <exception cref="ArgumentOutOfRangeException">If nextValue is equal to float.NaN.</exception>
public float NextValue(float nextValue)
{
if (float.IsNaN(nextValue))
throw new ArgumentOutOfRangeException("nextValue", "NaN may not be provided as the next value. It would corrupt the state of the calculation.");
// add new value to the sum
_sum += nextValue;
if (_valuesIn < _windowSize)
{
// we haven't yet filled our window
_valuesIn++;
}
else
{
// remove oldest value from sum
_sum -= _values[_nextValueIndex];
}
// store the value
_values[_nextValueIndex] = nextValue;
// progress the next value index pointer
_nextValueIndex++;
if (_nextValueIndex==_windowSize)
_nextValueIndex = 0;
return _sum / _valuesIn;
}
/// <summary>
/// Gets a value indicating whether enough values have been provided to fill the
/// speicified window size. Values returned from NextValue may still be used prior
/// to IsMature returning true, however such values are not subject to the intended
/// smoothing effect of the moving average's window size.
/// </summary>
public bool IsMature
{
get { return _valuesIn == _windowSize; }
}
/// <summary>
/// Clears any accumulated state and resets the calculator to its initial configuration.
/// Calling this method is the equivalent of creating a new instance.
/// </summary>
public void Reset()
{
_nextValueIndex = 0;
_sum = 0;
_valuesIn = 0;
}
}
To get the correct sorting on the .Sort method of the the Generic List, then objects that have been added to the list (e.g. of type <T>) should have implemented the IComparable interface and shold have implemented the CompareTo Method, such as:
class Person:IComparable { private string _FirstName; private int _Age; public Person(string _FirstName, int _Age) { this._FirstName = _FirstName; this._Age = _Age; } public string FirstName { get { return _FirstName; } set { _FirstName = value; } } public int Age { get { return _Age; } set { _Age = value; } } // sorting in ascending order public int CompareTo(object obj) { Person person = (Person) obj; return this.FirstName.CompareTo(person); } } However you can skip the need to implement the interface and CompareTo if you use a delegate on the call to the .Sort method as follows:List<Person> persons = new List<Person>(); persons.Add( new Person("Tom",30) ); persons.Add(new Person("Harry", 55)); // sort in ascending order persons.Sort( delegate(Person person0, Person person1) { return person0.FirstName.CompareTo(person1.FirstName); } ); // sort in descending order persons.Sort( delegate(Person person0, Person person1) { return person1.FirstName.CompareTo(person0.FirstName); } ); From: http://devintelligence.com/blogs/netadventures/archive/2007/01/16/sorting-system-collections-generic-list-t.aspx
from JD Meir, check out the following link for some really useful tips: http://msdn.microsoft.com/en-us/library/ms998530.aspx
Summary from the link: This guide provides end-to-end guidance for managing performance and scalability throughout your application life cycle to reduce risk and lower total cost of ownership. It provides a framework that organizes performance into a handful of prioritized categories where your choices heavily impact performance and scalability success. The logical units of the framework help integrate performance throughout your application life cycle. Information is segmented by roles, including architects, developers, testers, and administrators, to make it more relevant and actionable. This guide provides processes and actionable steps for modeling performance, measuring, testing, and tuning your applications. Expert guidance is also provided for improving the performance of managed code, ASP.NET, Enterprise Services, Web services, remoting, ADO.NET, XML, and SQL Server.
From the website: http://recaptcha.net/
A CAPTCHA is a program that can tell whether its user is a human or a computer. You’ve probably seen them — colorful images with distorted text at the bottom of Web registration forms. CAPTCHAs are used by many websites to prevent abuse from “bots,” or automated programs usually written to generate spam. No computer program can read distorted text as well as humans can, so bots cannot navigate sites protected by CAPTCHAs.
From: http://blogs.iis.net/ruslany/archive/2008/09/11/url-rewrite-module-go-live-release.aspx
“The IIS team has made the Go Live release of URL Rewrite Module for IIS 7.0 available for download. This release contains significant functionality and performance improvements and it is believed to have a quality level suitable for production deployments.
Here are the features that are new since CTP release (for a complete list of features and changes since CTP release, refer to this article):
If you want to convert the following from this:
<atom phase="gas">
<name>Hydrogen</name>
<symbol>H</symbol>
<boiling_point units="Kelvin">20.28</boiling_point>
</atom>
To this:
<atom phase="gas" name="Hydrogen" symbol="H">
<boiling_point units="Kelvin">20.28</boiling_point>
</atom>
Then the following XSLT can help:
<?xml version=’1.0′ encoding=’utf-8′?>
<xsl:stylesheet version=’1.0′ xmlns:xsl=’http://www.w3.org/1999/XSL/Transform’ xmlns:msxsl=’urn:schemas-microsoft-com:xslt’ exclude-result-prefixes=’msxsl’>
<xsl:template match=’*’>
<xsl:copy>
<xsl:for-each select=’@*|*[not(* or @*)]’>
<xsl:attribute name='{name(.)}’><xsl:value-of select=’.’/>
</xsl:attribute>
</xsl:for-each>
<xsl:apply-templates select=’*[* or @*]|text()’/>
</xsl:copy>
</xsl:template>
</xsl:stylesheet>
Hyper V with Windows 2008 seems to be great. Recently I helped move some of our old MS Virtual Machines from Virtual Server 2005 to Hyper V, and so far I am very happy with Hyper V.
To migrate a Windows 2003 Server there seemed to be several basic steps:
1) Remove the existing Virtual Machine Integration Services (i.e. the ones for Virtual Server 2005 or VPC 2007). you must do this BEFORE moving the VM across.
2) Make sure that the VM has Windows 2003 SP2 installed before moving across. Note just having 2003 R2 is not enough, you need SP2 as well.
3) Copy the virtual hard drive (VHD) to the new Hyper V server, and create a new virtual machine that uses that VHD.
4) Load the VM and install the Hyper V Integration Services (from the Hyper V VM manager you can do this from the menu). Note that your mouse will probably not work until you have done this, so you may have to brush up on your windows shortcut key skills 😉
5) That should be it. Try to avoid using the legacy network drivers etc; use the native Hyper V ones as the performance is much better.
You can read more about Hyper V at:
ANSI/IEEE Std 1471-2000 defines architecture as: “the fundamental organization of a system, embodied in its components, their relationships to each other and the environment, and the principles governing its design and evolution.”
Personally I am fan of the Bredemeyer team. Their definition in their VAP process is a lot more ‘punchy’, and makes a good deal more sense to a business audience. They simply put it as:
“The Technical Expression of Business Strategy”.
This portal has some useful EA stuff on it:
http://msdn.microsoft.com/en-gb/architecture/bb469938.aspx
I particualrly like the ‘A Day in the life of an Enterprise Architect’ article:
David Riddell McGhee, enterprise Account Technology Specialist for Microsoft Australia, has a really interesting blog, full of interesting things. Most recently i was reading about LinqToSharepoint.
This could be really useful for us as sharepoint is essentially our internal ECM system so integrating with it will become more common for us. From his blog:
Codeplex project:
http://www.codeplex.com/LINQtoSharePoint
Link I found this from:
http://dotnetaddict.dotnetdevelopersjournal.com/linq_to_sharepoint.htm
Video:
How Do I: Use LINQ To SharePoint to Retrieve SharePoint Data?
This could come in handy as many of our legacy virtual machines have small C drives, which over time can become an issue due to the size of modern software. Of course, take care and backup fully, as such a change may have issues. Done in two parts first use Gparted from http://gparted-livecd.tuxfamily.org/ to resize the VHD then use Gparted from http://gparted-livecd.tuxfamily.org/ to merge the old and new partions.
Check out the following link for details:
http://martyg.com.au/2008/01/05/resize-microsoft-virtual-hard-disks/
Click link for feed
A Tech Log 
